// pages/consult/chat.js
// 引入相关服务
const consultService = require('../../services/consult');
const hospitalService = require('../../services/hospital');
const util = require('../../utils/util');

// 消息发送状态
const MESSAGE_STATUS = {
  SENDING: 'SENDING',
  SUCCESS: 'SUCCESS',
  FAILED: 'FAILED'
};

// 消息类型
const MESSAGE_TYPE = {
  TEXT: 'TEXT',
  SYSTEM: 'SYSTEM'
};

Page({

  /**
   * 页面的初始数据
   */
  data: {
    staffId: null,
    staffName: '',
    staffAvatar: '',
    isOnline: false,
    conversationId: null,
    conversationStatus: 0, // 0-进行中，1-已结束
    userInfo: {},
    messages: [],
    inputContent: '',
    canSend: false,
    inputFocus: false,
    scrollIntoView: 'scroll-bottom',
    page: 1,
    pageSize: 20,
    hasMoreData: false,
    isLoadingMore: false,
    lastDateDivider: '',
    isPageShown: false,
    sending: false,  // 是否正在发送消息
    lastMessageId: 0, // 记录最后一条消息的ID，用于轮询新消息
    lastLoadTime: 0   // 记录最后一次加载消息的时间
  },

  // 轮询定时器
  pollTimer: null,

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log('聊天页面加载参数:', options);
    
    // 保存会话ID
    if (options.id) {
      // 首先使用URL中传递的状态参数，如果有的话
      let initialStatus = 0;
      if (options.status !== undefined) {
        initialStatus = parseInt(options.status);
        console.log('从URL参数中获取到会话状态:', initialStatus);
      }
      
      this.setData({
        conversationId: options.id,
        conversationStatus: initialStatus
      });
      
      // 加载会话详情
      this.loadConversationDetail(options.id);
      
      // 注意：不在这里调用loadMessages，而是在loadConversationDetail的成功回调中调用
      // 这样可以确保会话状态正确设置后再加载消息
      
      // 检查并确保WebSocket连接
      this.checkAndConnectWebSocket();
    } else {
      console.error('缺少会话ID参数');
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('聊天页面显示');
    
    // 标记页面为显示状态
    this.setData({
      isPageShown: true
    });
    
    // 如果有会话ID，则开始轮询消息
    if (this.data.conversationId) {
      console.log('页面显示时，开始轮询消息，会话ID:', this.data.conversationId);
      
      // 立即加载一次消息
      this.loadMessages(false);
      
      // 开始轮询
      this.startMessagePolling();
      
      // 标记消息为已读
      this.markMessagesAsRead();
    } else {
      console.log('无会话ID，不轮询消息');
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function() {
    console.log('聊天页面隐藏');
    
    // 标记页面为隐藏状态
    this.setData({
      isPageShown: false
    });
    
    // 停止轮询，但不清空消息
    this.stopMessagePolling();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function() {
    console.log('聊天页面卸载');

    // 停止轮询
    this.stopMessagePolling();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  /**
   * 加载医生信息
   */
  loadStaffInfo(staffId) {
    hospitalService.getStaffDetail(staffId)
      .then(res => {
        this.setData({
          staffName: res.name,
          staffAvatar: res.avatar,
          isOnline: res.online || false
        });
      })
      .catch(err => {
        console.error('获取医生信息失败', err);
      });
  },

  /**
   * 获取或创建会话
   */
  getOrCreateConversation(staffId) {
    console.log('开始获取或创建会话，医生ID:', staffId);
    wx.showLoading({
      title: '加载中...',
    });
    
    consultService.getOrCreateConversation(staffId)
      .then(res => {
        console.log('获取或创建会话成功:', res);
        this.setData({
          conversationId: res.id || res
        });
        
        // 加载历史消息
        this.loadHistoryMessages();
      })
      .catch(err => {
        console.error('获取会话失败，详细错误:', err);
        wx.hideLoading();
        
        wx.showToast({
          title: err.message || '获取会话失败',
          icon: 'none'
        });
      });
  },

  /**
   * 加载历史消息
   */
  loadHistoryMessages() {
    console.log('开始加载历史消息，会话ID:', this.data.conversationId);
    if (!this.data.conversationId) {
      console.error('无法加载历史消息，会话ID为空');
      wx.hideLoading();
      return;
    }
    
    const params = {
      conversationId: this.data.conversationId,
      page: this.data.page,
      pageSize: this.data.pageSize
    };
    
    console.log('历史消息请求参数:', params);
    
    consultService.getMessageList(params)
      .then(res => {
        console.log('获取历史消息成功:', res);
        const historyMessages = res.records || [];
        let lastDateStr = '';
        
        // 处理消息，添加日期分割线
        const messageList = historyMessages.map((item, index) => {
          // 格式化日期
          const createTime = new Date(item.createTime);
          const dateStr = util.formatDate(createTime);
          
          // 是否显示日期分割线
          const showDateDivider = dateStr !== lastDateStr;
          if (showDateDivider) {
            lastDateStr = dateStr;
          }
          
          return {
            ...item,
            showDateDivider,
            dateDivider: dateStr
          };
        }).reverse(); // 历史消息需要反转，最新的在底部
        
        this.setData({
          messages: messageList,
          hasMoreData: res.total > this.data.page * this.data.pageSize,
          lastDateDivider: lastDateStr,
          isLoadingMore: false
        });
        
        wx.hideLoading();
        
        // 滚动到底部
        this.scrollToBottom();
      })
      .catch(err => {
        console.error('获取历史消息失败，详细错误:', err);
        
        this.setData({
          isLoadingMore: false
        });
        
        wx.hideLoading();
        
        wx.showToast({
          title: err.message || '获取历史消息失败',
          icon: 'none'
        });
      });
  },

  /**
   * 滚动到底部
   */
  scrollToBottom: function() {
    console.log('滚动到消息底部');
    // 使用选择器获取消息列表的高度
    wx.createSelectorQuery()
      .select('#messageContainer')
      .boundingClientRect(rect => {
        if (rect) {
          this.setData({
            scrollTop: rect.height
          });
        }
      })
      .exec();
  },

  /**
   * 输入内容变化
   */
  onContentInput(e) {
    const content = e.detail.value.trim();
    
    this.setData({
      inputContent: e.detail.value,
      canSend: content.length > 0
    });
  },

  /**
   * 发送消息
   */
  sendMessage: function(e) {
    // 获取消息内容，优先从输入框事件中获取，其次从data中获取
    let content = '';
    if (e && e.detail && e.detail.value) {
      content = e.detail.value.trim();
    } else {
      content = this.data.inputValue ? this.data.inputValue.trim() : '';
    }
    
    // 检查消息内容
    if (!content) {
      console.log('消息内容为空，不发送');
      return;
    }
    
    // 检查会话ID
    if (!this.data.conversationId) {
      console.error('会话ID为空，无法发送消息');
      wx.showToast({
        title: '会话不存在',
        icon: 'none'
      });
      return;
    }

    // 检查会话是否已结束
    if (this.data.conversationStatus === 1) {
      wx.showToast({
        title: '会话已结束，不能发送消息',
        icon: 'none'
      });
      return;
    }
    
    console.log('准备发送消息，内容:', content, '会话ID:', this.data.conversationId);
    
    // 防止重复发送
    if (this.data.sending) {
      console.log('有消息正在发送中，请稍后再试');
      return;
    }
    
    this.setData({
      sending: true
    });
    
    // 获取当前用户信息
    const app = getApp();
    
    // 增强用户ID获取逻辑，尝试多种方式获取用户ID
    let userId = null;
    let userIdSource = '';
    
    // 确定当前用户类型
    const userType = app.globalData.userType;
    const isStaff = app.globalData.isStaff;
    console.log('当前用户类型:', userType, '是否医护人员:', isStaff);
    
    // 根据用户类型确定正确的senderType (0-普通用户，1-医护人员)
    let senderType = isStaff ? 1 : 0;
    
    // 根据用户类型选择正确的用户ID
    if (isStaff) {
      // 医护人员，从staffInfo获取ID
      if (app.globalData.staffInfo && app.globalData.staffInfo.id) {
        userId = app.globalData.staffInfo.id;
        userIdSource = '全局staffInfo';
      } else if (this.data.staffInfo && this.data.staffInfo.id) {
        userId = this.data.staffInfo.id;
        userIdSource = '页面staffInfo';
      }
    } else {
      // 普通用户，从userInfo获取ID
      if (app.globalData.userInfo && app.globalData.userInfo.id) {
        userId = app.globalData.userInfo.id;
        userIdSource = '全局userInfo';
      } else if (this.data.userInfo && this.data.userInfo.id) {
        userId = this.data.userInfo.id;
        userIdSource = '页面userInfo';
      }
    }
    
    // 如果还没找到ID，尝试从缓存恢复
    if (!userId) {
      try {
        if (isStaff) {
          const cachedStaffInfo = wx.getStorageSync('staffInfo');
          if (cachedStaffInfo && cachedStaffInfo.id) {
            userId = cachedStaffInfo.id;
            userIdSource = '缓存staffInfo';
          }
        } else {
          const cachedUserInfo = wx.getStorageSync('userInfo');
          if (cachedUserInfo && cachedUserInfo.id) {
            userId = cachedUserInfo.id;
            userIdSource = '缓存userInfo';
          }
        }
      } catch (e) {
        console.error('从缓存获取用户信息失败:', e);
      }
    }
    
    console.log('用户ID获取结果:', userId, '来源:', userIdSource, '用户类型:', userType, '发送者类型:', senderType);
    
    if (!userId) {
      console.error('用户ID为空，无法发送消息');
      
      this.setData({
        sending: false
      });
      
      // 提示用户重新登录
      wx.showModal({
        title: '发送失败',
        content: '获取用户信息失败，需要重新登录',
        confirmText: '去登录',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            app.clearLoginInfo();
            wx.navigateTo({
              url: '/pages/login/login'
            });
          }
        }
      });
      return;
    }
    
    // 生成临时消息ID
    const tempMessageId = 'temp_' + Date.now();
    
    // 先在UI上显示一个临时消息
    const tempMessage = {
      id: tempMessageId,
      conversationId: this.data.conversationId,
      content: content,
      senderId: userId,
      senderType: senderType,
      contentType: 0, // 文本消息
      createTime: new Date(),
      status: 'SENDING', // 用于显示发送中状态
      isSelf: true, // 肯定是自己发送的
      formattedTime: this.formatTime(new Date()) // 格式化当前时间
    };
    
    // 添加到消息列表
    const messages = [...this.data.messages, tempMessage];
    this.setData({
      messages: messages,
      inputValue: '' // 清空输入框
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    // 使用HTTP发送消息
    this.sendMessageViaHttp(tempMessage);
  },
  
  /**
   * 通过HTTP发送消息
   */
  sendMessageViaHttp: function(messageData) {
    const that = this;
    const app = getApp();
    
    // 确保senderType正确设置
    const isStaff = app.globalData.isStaff;
    let senderType = isStaff ? 1 : 0; // 1=医护人员, 0=普通用户
    
    // 创建一个符合后端 MessageDTO 格式的消息对象，只包含必要的字段
    const apiMessageData = {
      content: messageData.content,
      senderId: messageData.senderId,
      senderType: senderType, // 确保使用正确的类型
      contentType: messageData.contentType || 0 // 默认为文本消息
    };
    
    // 记录原始消息ID，用于更新状态
    const originalMessageId = messageData.id;
    
    console.log('通过HTTP发送消息:', apiMessageData);
    
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${this.data.conversationId}`,
      method: 'POST',
      data: apiMessageData,
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${app.globalData.token}`
      },
      success: function(res) {
        console.log('消息发送结果:', res);
        // 修改判断逻辑，只要状态码为200就认为成功
        // 因为后端可能返回的数据结构不统一，有些接口不带code字段
        if (res.statusCode === 200) {
          let messageId = null;
          
          // 尝试从不同的响应格式中获取消息ID
          if (res.data && res.data.data && res.data.data.id) {
            // 标准格式：{ code: 0, data: { id: xxx } }
            messageId = res.data.data.id;
          } else if (res.data && res.data.id) {
            // 简化格式：{ id: xxx }
            messageId = res.data.id;
          } else if (typeof res.data === 'object') {
            // 尝试在返回对象中查找id字段
            for (const key in res.data) {
              if (res.data[key] && res.data[key].id) {
                messageId = res.data[key].id;
                break;
              }
            }
          }
          
          // 更新本地消息状态为已发送
          that.updateMessageStatus(originalMessageId, 'sent');
          
          // 如果找到了真实的消息ID，更新本地消息ID
          if (messageId) {
            that.updateMessageId(originalMessageId, messageId);
          }
          
          // 一次成功后，马上轮询一次以获取最新消息
          setTimeout(() => {
            that.loadMessages(false);
          }, 300);
        } else {
          console.error('消息发送失败:', res);
          // 更新本地消息状态为发送失败
          that.updateMessageStatus(originalMessageId, 'failed');
          
          // 显示发送失败提示
          wx.showToast({
            title: (res.data && res.data.message) ? res.data.message : '发送失败，请重试',
            icon: 'none'
          });
        }
        
        that.setData({
          sending: false
        });
      },
      fail: function(err) {
        console.error('网络请求失败:', err);
        // 更新本地消息状态为发送失败
        that.updateMessageStatus(originalMessageId, 'failed');
        that.setData({
          sending: false
        });
        
        // 显示发送失败提示
        wx.showToast({
          title: '网络错误，发送失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 更新消息状态
   */
  updateMessageStatus: function(messageId, status) {
    console.log('更新消息状态:', messageId, status);
    const messages = this.data.messages;
    
    // 找到对应消息的索引
    const index = messages.findIndex(msg => msg.id === messageId);
    if (index === -1) {
      console.error('未找到要更新状态的消息:', messageId);
      return;
    }
    
    // 更新消息状态
    messages[index].status = status;
    
    // 更新界面
    this.setData({
      [`messages[${index}].status`]: status
    });
    
    // 如果消息发送成功并且是自己发的，滚动到底部
    if (status === 'sent' && messages[index].isSelf) {
      this.scrollToBottom();
    }
  },
  
  /**
   * 更新消息ID（将临时ID更新为服务器返回的真实ID）
   */
  updateMessageId: function(oldId, newId) {
    console.log('更新消息ID:', oldId, '->', newId);
    const messages = this.data.messages;
    
    // 找到对应消息的索引
    const index = messages.findIndex(msg => msg.id === oldId);
    if (index === -1) {
      console.error('未找到要更新ID的消息:', oldId);
      return;
    }
    
    // 更新消息ID
    messages[index].id = newId;
    
    // 更新界面
    this.setData({
      [`messages[${index}].id`]: newId
    });
    
    // 同时更新最后一条消息ID，便于轮询
    if (newId > this.data.lastMessageId) {
      this.setData({
        lastMessageId: newId
      });
    }
  },

  /**
   * 重发消息
   */
  resendMessage: function(e) {
    const messageId = e.currentTarget.dataset.id;
    console.log('尝试重发消息 ID:', messageId);
    
    // 在消息数组中查找对应ID的消息
    const index = this.data.messages.findIndex(msg => msg.id === messageId);
    if (index === -1) {
      console.error('未找到要重发的消息:', messageId);
      return;
    }
    
    const message = this.data.messages[index];
    
    if (message.status !== 'FAILED' && message.status !== 'failed') {
      console.log('消息状态不是失败，不需要重发');
      return;
    }
    
    console.log('重发消息:', message);
    
    // 更新消息状态为发送中
    this.updateMessageStatus(message.id, 'SENDING');
    
    // 获取当前登录用户信息
    const app = getApp();
    const isStaff = app.globalData.isStaff;
    let senderType = isStaff ? 1 : 0; // 1=医护人员, 0=普通用户
    
    // 检查消息是否包含必要的发送者ID
    if (!message.senderId) {
      console.error('消息缺少发送者ID，无法重发');
      
      // 尝试从用户信息中获取发送者ID
      let senderId = null;
      let userIdSource = '';
      
      // 根据用户类型选择正确的用户ID
      if (isStaff) {
        // 医护人员，从staffInfo获取ID
        if (app.globalData.staffInfo && app.globalData.staffInfo.id) {
          senderId = app.globalData.staffInfo.id;
          userIdSource = '全局staffInfo';
        } else if (this.data.staffInfo && this.data.staffInfo.id) {
          senderId = this.data.staffInfo.id;
          userIdSource = '页面staffInfo';
        }
      } else {
        // 普通用户，从userInfo获取ID
        if (app.globalData.userInfo && app.globalData.userInfo.id) {
          senderId = app.globalData.userInfo.id;
          userIdSource = '全局userInfo';
        } else if (this.data.userInfo && this.data.userInfo.id) {
          senderId = this.data.userInfo.id;
          userIdSource = '页面userInfo';
        }
      }
      
      // 如果还没找到ID，尝试从缓存恢复
      if (!senderId) {
        try {
          if (isStaff) {
            const cachedStaffInfo = wx.getStorageSync('staffInfo');
            if (cachedStaffInfo && cachedStaffInfo.id) {
              senderId = cachedStaffInfo.id;
              userIdSource = '缓存staffInfo';
            }
          } else {
            const cachedUserInfo = wx.getStorageSync('userInfo');
            if (cachedUserInfo && cachedUserInfo.id) {
              senderId = cachedUserInfo.id;
              userIdSource = '缓存userInfo';
            }
          }
        } catch (e) {
          console.error('从缓存获取用户信息失败:', e);
        }
      }
      
      console.log('用户ID获取结果:', senderId, '来源:', userIdSource, '发送者类型:', senderType);
      
      if (!senderId) {
        wx.showModal({
          title: '无法重发',
          content: '获取用户信息失败，需要重新登录',
          confirmText: '去登录',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              app.clearLoginInfo();
              wx.navigateTo({
                url: '/pages/login/login'
              });
            } else {
              // 恢复消息状态为失败
              this.updateMessageStatus(message.id, 'failed');
            }
          }
        });
        return;
      }
      
      // 更新消息的发送者ID
      message.senderId = senderId;
      console.log('已更新消息发送者ID:', senderId);
    }
    
    // 始终更新发送者类型为当前用户类型
    message.senderType = senderType;
    console.log('已更新消息发送者类型:', senderType);
    
    // 设置发送状态
    this.setData({
      sending: true
    });
    
    // 构建消息对象用于发送
    const apiMessageData = {
      content: message.content,
      senderId: message.senderId,
      senderType: senderType,
      contentType: message.contentType || 0
    };
    
    console.log('重发消息对象:', apiMessageData);
    
    // 判断本地图片路径（以"wxfile:"开头）是否需要重新上传
    if (message.contentType === 1 && message.content.startsWith('wxfile:')) {
      console.log('检测到本地图片路径，需要重新上传图片:', message.content);
      this.uploadImage(message.content);
      
      // 更新原消息状态为已处理，防止重复显示
      this.updateMessageStatus(message.id, 'handled');
      
      // 停止继续执行发送
      this.setData({
        sending: false
      });
      return;
    }
    
    // 使用HTTP方式发送
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${this.data.conversationId}`,
      method: 'POST',
      data: apiMessageData,
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${app.globalData.token}`
      },
      success: (res) => {
        console.log('消息重发结果:', res);
        if (res.statusCode === 200 && res.data && res.data.code === 0) {
          // 更新本地消息状态为已发送
          this.updateMessageStatus(message.id, 'sent');
          
          // 如果服务器返回了真实的消息ID，更新本地消息ID
          if (res.data.data && res.data.data.id) {
            this.updateMessageId(message.id, res.data.data.id);
          }
          
          // 成功后轮询一次消息
          setTimeout(() => {
            this.loadMessages(false);
          }, 300);
          
          wx.showToast({
            title: '消息已重发',
            icon: 'success'
          });
        } else {
          // 更新本地消息状态为发送失败
          this.updateMessageStatus(message.id, 'failed');
          
          wx.showToast({
            title: (res.data && res.data.message) ? res.data.message : '重发失败，请重试',
            icon: 'none'
          });
        }
        
        this.setData({
          sending: false
        });
      },
      fail: (err) => {
        console.error('消息重发请求失败:', err);
        
        // 更新本地消息状态为发送失败
        this.updateMessageStatus(message.id, 'failed');
        
        this.setData({
          sending: false
        });
        
        wx.showToast({
          title: '网络错误，重发失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 向上滚动加载更多历史消息
   */
  onScrollToUpper() {
    if (this.data.isLoadingMore || !this.data.hasMoreData) {
      return;
    }
    
    this.setData({
      isLoadingMore: true,
      page: this.data.page + 1
    });
    
    const params = {
      conversationId: this.data.conversationId,
      page: this.data.page,
      pageSize: this.data.pageSize
    };
    
    consultService.getMessageList(params)
      .then(res => {
        const historyMessages = res.records || [];
        let lastDateStr = this.data.lastDateDivider;
        
        // 处理消息，添加日期分割线
        const moreMessages = historyMessages.map((item, index) => {
          // 格式化日期
          const createTime = new Date(item.createTime);
          const dateStr = util.formatDate(createTime);
          
          // 是否显示日期分割线
          const showDateDivider = dateStr !== lastDateStr;
          if (showDateDivider) {
            lastDateStr = dateStr;
          }
          
          return {
            ...item,
            showDateDivider,
            dateDivider: dateStr
          };
        }).reverse(); // 历史消息需要反转，最新的在底部
        
        this.setData({
          messages: [...moreMessages, ...this.data.messages],
          hasMoreData: res.total > this.data.page * this.data.pageSize,
          isLoadingMore: false
        });
      })
      .catch(err => {
        console.error('获取更多历史消息失败', err);
        
        this.setData({
          isLoadingMore: false,
          page: this.data.page - 1
        });
        
        wx.showToast({
          title: err.message || '获取历史消息失败',
          icon: 'none'
        });
      });
  },

  /**
   * 返回上一页
   */
  goBack: function() {
    // 设置手动离开标记，以便在页面卸载时关闭WebSocket
    this.setData({
      manualLeave: true
    });
    console.log('用户手动返回，设置manualLeave标记为true');
    wx.navigateBack();
  },

  /**
   * 结束咨询会话
   */
  endConsultation: function() {
    const that = this;
    wx.showModal({
      title: '结束咨询',
      content: '确定要结束本次咨询吗？',
      confirmColor: '#FF4D4F',
      success(res) {
        if (res.confirm) {
          // 设置手动离开标记
          that.setData({
            manualLeave: true
          });
          console.log('用户结束咨询，设置manualLeave标记为true');
          
          // 显示加载中
          wx.showLoading({
            title: '正在结束咨询',
            mask: true
          });
          
          // 停止轮询消息
          that.stopMessagePolling();
          
          // 调用结束会话接口
          consultService.endConversation(that.data.conversationId)
            .then(res => {
              console.log('咨询已结束:', res);
              wx.hideLoading();
              
              wx.showToast({
                title: '咨询已结束',
                icon: 'success'
              });
              
              // 返回到上一页
              wx.navigateBack();
            })
            .catch(err => {
              console.error('结束咨询失败:', err);
              wx.hideLoading();
              
              wx.showToast({
                title: err.message || '结束咨询失败',
                icon: 'none'
              });
            });
        }
      }
    });
  },

  // 标记消息为已读
  markMessagesAsRead() {
    if (!this.data.conversationId) {
      console.log('无会话ID，不标记消息为已读');
      return;
    }
    
    console.log('标记会话消息为已读，会话ID:', this.data.conversationId);
    
    // 调用标记消息为已读的API
    consultService.readMessages(this.data.conversationId)
      .then(res => {
        console.log('标记消息已读成功');
      })
      .catch(err => {
        console.error('标记消息已读失败:', err);
      });
  },

  /**
   * 加载会话详情
   */
  loadConversationDetail: function(conversationId) {
    console.log('加载会话详情，会话ID:', conversationId);
    
    if (!conversationId) {
      console.error('会话ID为空，无法加载会话详情');
      return;
    }
    
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    const app = getApp();
    // 不再调用/consult/conversation/detail/${conversationId}
    // 而是直接使用消息API来获取会话信息
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${conversationId}`,
      method: 'GET',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${app.globalData.token}`
      },
      success: (res) => {
        console.log('获取会话消息结果:', res);
        wx.hideLoading();
        
        // 尝试从消息API响应中提取会话信息
        let conversation = null;
        
        if (res.statusCode === 200) {
          // 尝试从不同格式的响应中提取会话数据
          if (res.data && res.data.data && res.data.data.conversation) {
            conversation = res.data.data.conversation;
          } else if (res.data && res.data.conversation) {
            conversation = res.data.conversation;
          }
          
          // 如果找到了会话信息
          if (conversation) {
            console.log('从消息API中获取到会话信息:', conversation);
            
            // 检查当前用户是普通用户还是医生
            const userId = app.globalData.isStaff ? 
              (app.globalData.staffInfo ? app.globalData.staffInfo.id : null) : 
              (app.globalData.userInfo ? app.globalData.userInfo.id : null);
            
            // 更新页面数据
            this.setData({
              conversationDetail: conversation,
              staffId: conversation.staffId,
              conversationStatus: conversation.status || 0 // 设置会话状态
            });

            // 获取医生信息
            if (conversation.staffId) {
              this.loadStaffInfo(conversation.staffId);
            }

            // 如果会话已结束，显示提示并禁用发送功能
            if (conversation.status === 1) {
              console.log('检测到会话已结束，状态值:', conversation.status);
              wx.showToast({
                title: '会话已结束，仅可查看历史消息',
                icon: 'none',
                duration: 2000
              });
            } else {
              console.log('会话进行中，状态值:', conversation.status || 0);
            }
          } else {
            console.log('消息API中未找到会话信息，使用默认状态');
            // 如果无法从消息API获取会话状态，使用URL中传递的状态
            console.log('使用从URL获取的会话状态:', this.data.conversationStatus);
          }
          
          // 加载历史消息
          this.loadMessages(true);
        } else {
          console.error('获取消息失败:', res.statusCode);
          wx.showToast({
            title: '获取会话信息失败',
            icon: 'none',
            duration: 1500
          });
        }
      },
      fail: (err) => {
        console.error('请求消息失败:', err);
        wx.hideLoading();
        
        // 网络错误时显示简短提示
        wx.showToast({
          title: '网络错误，请稍后再试',
          icon: 'none',
          duration: 1500
        });
      }
    });
  },

  /**
   * 尝试从消息中获取医生信息（当会话详情失败时的备用方案）
   */
  tryGetStaffInfoFromMessages: function() {
    // 直接使用loadMessages加载消息，其中已包含获取会话信息的逻辑
    console.log('尝试从消息中获取会话和医生信息');
    this.loadMessages(true);
  },

  /**
   * 加载会话消息历史
   * @param {boolean} refresh 是否刷新全部消息
   */
  loadMessages: function(refresh = false) {
    // 防止频繁请求，至少间隔1秒
    const now = Date.now();
    if (!refresh && now - this.data.lastLoadTime < 1000) {
      console.log('请求过于频繁，跳过本次加载');
      return;
    }
    
    this.setData({
      lastLoadTime: now
    });
    
    // 如果是刷新，显示页码1，否则检查是否有新消息
    const page = refresh ? 1 : 1; // 轮询模式下总是获取最新消息
    console.log('加载会话消息，会话ID:', this.data.conversationId, '页码:', page);
    
    if (!this.data.conversationId) {
      console.error('会话ID为空，无法加载消息');
      return;
    }
    
    // 只有在刷新时才显示加载提示，轮询时静默加载
    if (refresh) {
      wx.showLoading({
        title: '加载消息...',
        mask: false
      });
    }
    
    // 调用获取消息的API
    const app = getApp();
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${this.data.conversationId}`,
      method: 'GET',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${app.globalData.token}`
      },
      success: (res) => {
        console.log('获取消息结果:', res);
        
        // 尝试从不同格式的响应中提取数据
        let records = [];
        let total = 0;
        let conversation = null;
        
        if (res.statusCode === 200) {
          // 尝试从标准响应格式中提取数据
          if (res.data && res.data.data) {
            if (res.data.data.records) {
              records = res.data.data.records;
              total = res.data.data.total || 0;
            } else if (Array.isArray(res.data.data)) {
              records = res.data.data;
              total = records.length;
            }
            
            // 尝试获取会话信息
            if (res.data.data.conversation) {
              conversation = res.data.data.conversation;
            }
          } else if (res.data && res.data.records) {
            // 直接在响应根对象中的记录
            records = res.data.records;
            total = res.data.total || 0;
            
            // 尝试获取会话信息
            if (res.data.conversation) {
              conversation = res.data.conversation;
            }
          } else if (res.data && Array.isArray(res.data)) {
            // 直接是数组
            records = res.data;
            total = records.length;
          }
        }
        
        // 同时检查服务器返回的会话信息，确保状态同步
        if (conversation && conversation.status !== undefined) {
          const serverStatus = parseInt(conversation.status); // 确保是数字
          
          // 如果服务器返回的会话状态与本地不一致，更新本地状态
          if (serverStatus !== this.data.conversationStatus) {
            console.log('服务器返回的会话状态与本地不一致，更新状态', 
                       '本地状态:', this.data.conversationStatus, 
                       '服务器状态:', serverStatus);
            
            this.setData({
              conversationStatus: serverStatus
            });
            
            // 如果会话已结束，显示提示
            if (serverStatus === 1) {
              wx.showToast({
                title: '会话已结束，仅可查看历史消息',
                icon: 'none',
                duration: 2000
              });
            }
          }
          
          // 如果有医生ID但没有设置staffId，则设置并加载医生信息
          if (conversation.staffId && !this.data.staffId) {
            this.setData({
              staffId: conversation.staffId
            });
            this.loadStaffInfo(conversation.staffId);
          }
        } else {
          // 如果服务器没有返回会话状态信息，但URL中传递了状态参数，尝试从消息内容推断会话状态
          console.log('服务器未返回会话状态信息，尝试从消息内容推断');
          
          // 1. 先从URL参数中获取的状态
          const urlStatus = this.data.conversationStatus;
          console.log('从URL获取的会话状态:', urlStatus);
          
          // 2. 检查是否有系统消息表明会话已结束
          let hasEndMessage = false;
          if (records && records.length > 0) {
            // 查找是否有系统消息表明会话已结束
            hasEndMessage = records.some(msg => 
              (msg.type === 'SYSTEM' || msg.contentType === 2) && 
              msg.content && 
              (msg.content.includes('结束') || msg.content.includes('ended'))
            );
            
            if (hasEndMessage) {
              console.log('从消息内容中检测到会话已结束');
            }
            
            // 3. 检查消息是否来自医生
            const hasStaffMessage = records.some(msg => msg.senderType === 1);
            if (hasStaffMessage) {
              console.log('检测到会话包含医生发送的消息');
            }
            
            // 4. 检查最后一条消息的时间，如果超过7天，可能已结束
            try {
              const lastMsg = records[records.length - 1];
              if (lastMsg && lastMsg.createTime) {
                const createTime = new Date(lastMsg.createTime.replace(/-/g, '/'));
                const now = new Date();
                const daysDiff = Math.floor((now - createTime) / (1000 * 60 * 60 * 24));
                
                console.log('最后一条消息时间:', createTime, '距今天数:', daysDiff);
                
                if (daysDiff > 7) {
                  hasEndMessage = true;
                  console.log('最后一条消息已超过7天，可能会话已结束');
                }
              }
            } catch (e) {
              console.error('解析消息时间出错:', e);
            }
          }
          
          // 如果有结束标志，修改会话状态
          if (hasEndMessage && urlStatus !== 1) {
            console.log('从消息内容推断会话已结束，更新状态');
            this.setData({
              conversationStatus: 1
            });
            
            wx.showToast({
              title: '会话已结束，仅可查看历史消息',
              icon: 'none',
              duration: 2000
            });
          }
        }
        
        const isLastPage = page >= Math.ceil(total / this.data.pageSize);
        
        if (records.length > 0) {
          console.log('获取到消息，数量:', records.length, '总数:', total);
          
          // 获取最新消息的ID
          const latestMessageId = records.length > 0 ? 
            Math.max(...records.map(msg => msg.id || 0)) : 0;
          
          // 检查是否有新消息
          if (latestMessageId > this.data.lastMessageId) {
            console.log('检测到新消息，最新消息ID:', latestMessageId, '上次消息ID:', this.data.lastMessageId);
            
            // 格式化消息
            let formattedMessages = this.formatMessages(records);
            
            // 如果是刷新，直接替换消息列表
            if (refresh) {
              this.setData({
                messages: formattedMessages,
                isLastPage: isLastPage,
                page: 1,
                lastMessageId: latestMessageId
              });
              
              // 滚动到底部
              this.scrollToBottom();
            } else {
              // 否则，过滤出新消息添加到现有消息列表末尾
              const existingIds = this.data.messages.map(msg => msg.id);
              const newMessages = formattedMessages.filter(msg => !existingIds.includes(msg.id));
              
              if (newMessages.length > 0) {
                console.log('添加新消息到列表，数量:', newMessages.length);
                
                // 将新消息添加到现有消息列表末尾
                this.setData({
                  messages: [...this.data.messages, ...newMessages],
                  lastMessageId: latestMessageId
                });
                
                // 播放提示音
                if (newMessages.some(msg => !msg.isSelf)) {
                  this.playMessageSound();
                }
                
                // 滚动到底部
                this.scrollToBottom();
                
                // 标记消息为已读
                this.markMessagesAsRead();
              }
            }
          } else {
            console.log('没有新消息，最新消息ID:', latestMessageId);
          }
        } else {
          console.log('没有获取到任何消息');
        }
        
        // 只有在刷新时才隐藏加载提示
        if (refresh) {
          wx.hideLoading();
        }
      },
      fail: (err) => {
        console.error('获取会话消息失败:', err);
        if (refresh) {
          wx.hideLoading();
          wx.showToast({
            title: '获取消息失败',
            icon: 'none'
          });
        }
      }
    });
  },
  
  /**
   * 格式化消息数据
   */
  formatMessages: function(messages) {
    if (!messages || messages.length === 0) {
      return [];
    }
    
    // 获取当前用户ID
    const app = getApp();
    const currentUserId = app.globalData.isStaff ? 
      (app.globalData.staffInfo ? app.globalData.staffInfo.id : 0) : 
      (app.globalData.userInfo ? app.globalData.userInfo.id : 0);
    
    console.log('当前用户ID:', currentUserId);
    
    // 格式化消息
    const formattedMessages = messages.map(msg => {
      // 确定消息是否由当前用户发送
      const isSelf = app.globalData.isStaff ? 
        (msg.senderType === 1 && msg.senderId == currentUserId) : 
        (msg.senderType === 0 && msg.senderId == currentUserId);
      
      // 处理创建时间
      let createTimeStr = msg.createTime;
      
      // 标准化日期格式以兼容iOS
      if (createTimeStr && typeof createTimeStr === 'string') {
        // 将yyyy-MM-dd HH:mm:ss转换为yyyy/MM/dd HH:mm:ss以兼容iOS
        createTimeStr = createTimeStr.replace(/-/g, '/');
      }
      
      // 格式化时间
      const createTime = createTimeStr ? new Date(createTimeStr) : new Date();
      const formattedTime = this.formatTime(createTime);
      
      return {
        ...msg,
        isSelf: isSelf,
        formattedTime: formattedTime,
        contentType: msg.contentType || 0 // 确保contentType存在，默认为文本类型
      };
    });
    
    return formattedMessages;
  },
  
  /**
   * 格式化时间
   */
  formatTime: function(date) {
    if (!date) return '';
    
    const year = date.getFullYear();
    const month = date.getMonth() + 1;
    const day = date.getDate();
    const hour = date.getHours();
    const minute = date.getMinutes();
    
    const now = new Date();
    const isToday = now.getDate() === day && 
                    now.getMonth() === date.getMonth() && 
                    now.getFullYear() === year;
    
    if (isToday) {
      return `${this.padZero(hour)}:${this.padZero(minute)}`;
    } else {
      return `${year}-${this.padZero(month)}-${this.padZero(day)} ${this.padZero(hour)}:${this.padZero(minute)}`;
    }
  },
  
  /**
   * 数字补零
   */
  padZero: function(num) {
    return num < 10 ? '0' + num : num;
  },

  /**
   * 处理输入框内容变化
   */
  handleInputChange: function(e) {
    this.setData({
      inputValue: e.detail.value
    });
  },

  /**
   * 开始轮询消息
   */
  startMessagePolling: function() {
    const that = this;
    this.pollTimer = setInterval(() => {
      that.loadMessages(false);
    }, 5000); // 每5秒轮询一次
  },

  /**
   * 停止轮询消息
   */
  stopMessagePolling: function() {
    if (this.pollTimer) {
      clearInterval(this.pollTimer);
      this.pollTimer = null;
    }
  },

  /**
   * 播放消息提示音
   */
  playMessageSound: function() {
    try {
      // 使用微信小程序的新消息提示API
      wx.vibrateShort({
        type: 'medium'
      });
      // 使用内置声音
      const innerAudioContext = wx.createInnerAudioContext();
      innerAudioContext.src = 'https://res.wx.qq.com/voice/getvoice?mediaid=MzI0NTk3NzM1M18yMjQ3NTA0NjU0';
      innerAudioContext.play();
      
      innerAudioContext.onError((res) => {
        console.error('播放消息提示音失败:', res);
      });
    } catch (e) {
      console.error('播放消息提示音失败:', e);
    }
  },

  /**
   * 选择图片
   */
  chooseImage: function() {
    // 检查会话是否已结束
    if (this.data.conversationStatus === 1) {
      wx.showToast({
        title: '会话已结束，不能发送消息',
        icon: 'none'
      });
      return;
    }

    const that = this;
    
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album', 'camera'],
      success: function(res) {
        console.log('选择图片成功：', res);
        const tempFilePath = res.tempFiles[0].tempFilePath;
        
        // 显示加载中
        wx.showLoading({
          title: '正在发送...',
          mask: true
        });
        
        // 先上传图片，再发送消息
        that.uploadImage(tempFilePath);
      },
      fail: function(err) {
        console.error('选择图片失败：', err);
        
        // 确保loading被关闭
        wx.hideLoading();
        
        if (err.errMsg !== 'chooseMedia:fail cancel') {
          wx.showToast({
            title: '选择图片失败',
            icon: 'none'
          });
        }
      }
    });
  },

  /**
   * 上传图片
   */
  uploadImage: function(filePath) {
    const that = this;
    const app = getApp();
    
    // 先在UI上显示一个临时消息
    const tempMessageId = 'temp_' + Date.now();
    
    // 获取发送者信息
    let userId = null;
    let userIdSource = '';
    
    // 确定当前用户类型
    const isStaff = app.globalData.isStaff;
    const senderType = isStaff ? 1 : 0; // 1=医护人员, 0=普通用户
    
    // 根据用户类型选择正确的用户ID
    if (isStaff) {
      // 医护人员，从staffInfo获取ID
      if (app.globalData.staffInfo && app.globalData.staffInfo.id) {
        userId = app.globalData.staffInfo.id;
        userIdSource = '全局staffInfo';
      } else if (this.data.staffInfo && this.data.staffInfo.id) {
        userId = this.data.staffInfo.id;
        userIdSource = '页面staffInfo';
      }
    } else {
      // 普通用户，从userInfo获取ID
      if (app.globalData.userInfo && app.globalData.userInfo.id) {
        userId = app.globalData.userInfo.id;
        userIdSource = '全局userInfo';
      } else if (this.data.userInfo && this.data.userInfo.id) {
        userId = this.data.userInfo.id;
        userIdSource = '页面userInfo';
      }
    }
    
    // 如果还没找到ID，尝试从缓存恢复
    if (!userId) {
      try {
        if (isStaff) {
          const cachedStaffInfo = wx.getStorageSync('staffInfo');
          if (cachedStaffInfo && cachedStaffInfo.id) {
            userId = cachedStaffInfo.id;
            userIdSource = '缓存staffInfo';
          }
        } else {
          const cachedUserInfo = wx.getStorageSync('userInfo');
          if (cachedUserInfo && cachedUserInfo.id) {
            userId = cachedUserInfo.id;
            userIdSource = '缓存userInfo';
          }
        }
      } catch (e) {
        console.error('从缓存获取用户信息失败:', e);
      }
    }
    
    console.log('用户ID获取结果:', userId, '来源:', userIdSource, '发送者类型:', senderType);
    
    if (!userId) {
      wx.hideLoading();
      console.error('用户ID为空，无法发送图片消息');
      
      // 提示用户重新登录
      wx.showModal({
        title: '发送失败',
        content: '获取用户信息失败，需要重新登录',
        confirmText: '去登录',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            app.clearLoginInfo();
            wx.navigateTo({
              url: '/pages/login/login'
            });
          }
        }
      });
      return;
    }
    
    // 在消息列表中先显示本地图片
    const tempMessage = {
      id: tempMessageId,
      conversationId: this.data.conversationId,
      content: filePath,  // 临时文件路径
      senderId: userId,
      senderType: senderType,
      contentType: 1,  // 图片类型
      createTime: new Date(),
      status: 'sending', // 发送中状态
      isSelf: true, // 肯定是自己发送的
      formattedTime: this.formatTime(new Date()) // 格式化当前时间
    };
    
    // 添加到消息列表
    const messages = [...this.data.messages, tempMessage];
    this.setData({
      messages: messages
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    // 执行图片上传
    wx.uploadFile({
      url: `${app.globalData.baseUrl}/file/upload`,
      filePath: filePath,
      name: 'file',
      header: {
        'Authorization': `Bearer ${app.globalData.token}`
      },
      formData: {
        'type': 'chat' // 指定模块为chat类型
      },
      success: function(res) {
        console.log('图片上传结果：', res);
        
        try {
          // 解析返回的JSON字符串
          const data = JSON.parse(res.data);
          
          if (data.code === 0 || data.code === 200) {
            // 上传成功，获取图片URL
            const imageUrl = data.data;
            console.log('图片上传成功，URL：', imageUrl);
            
            // 更新临时消息中的图片URL
            that.updateMessageContent(tempMessageId, imageUrl);
            
            // 发送包含图片URL的消息
            that.sendImageMessage(tempMessageId, imageUrl, userId, senderType);
          } else {
            // 上传失败
            console.error('图片上传失败：', data.message || '服务器返回错误');
            that.updateMessageStatus(tempMessageId, 'failed');
            wx.hideLoading();
            
            wx.showToast({
              title: data.message || '图片上传失败',
              icon: 'none'
            });
          }
        } catch (e) {
          console.error('解析上传响应失败：', e, res.data);
          that.updateMessageStatus(tempMessageId, 'failed');
          wx.hideLoading();
          
          wx.showToast({
            title: '图片上传失败',
            icon: 'none'
          });
        }
      },
      fail: function(err) {
        console.error('图片上传请求失败：', err);
        that.updateMessageStatus(tempMessageId, 'failed');
        wx.hideLoading();
        
        wx.showToast({
          title: '网络错误，图片上传失败',
          icon: 'none'
        });
      },
      complete: function() {
        // 确保在错误情况下也隐藏加载提示
        try {
          wx.hideLoading();
        } catch (e) {
          console.error('关闭loading失败:', e);
        }
      }
    });
  },
  
  /**
   * 更新消息内容
   */
  updateMessageContent: function(messageId, content) {
    console.log('更新消息内容:', messageId, content);
    const messages = this.data.messages;
    
    // 找到对应消息的索引
    const index = messages.findIndex(msg => msg.id === messageId);
    if (index === -1) {
      console.error('未找到要更新内容的消息:', messageId);
      return;
    }
    
    // 更新消息内容
    messages[index].content = content;
    
    // 更新界面
    this.setData({
      [`messages[${index}].content`]: content
    });
  },
  
  /**
   * 发送图片消息
   */
  sendImageMessage: function(tempMessageId, imageUrl, senderId, senderType) {
    const that = this;
    const app = getApp();
    
    // 构建消息对象
    const apiMessageData = {
      content: imageUrl,
      senderId: senderId,
      senderType: senderType,
      contentType: 1 // 图片类型
    };
    
    console.log('发送图片消息:', apiMessageData);
    
    // 使用HTTP API发送消息
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${this.data.conversationId}`,
      method: 'POST',
      data: apiMessageData,
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${app.globalData.token}`
      },
      success: function(res) {
        console.log('图片消息发送结果:', res);
        // 修改判断逻辑，只要状态码为200就认为成功
        if (res.statusCode === 200) {
          let messageId = null;
          
          // 尝试从不同的响应格式中获取消息ID
          if (res.data && res.data.data && res.data.data.id) {
            // 标准格式：{ code: 0, data: { id: xxx } }
            messageId = res.data.data.id;
          } else if (res.data && res.data.id) {
            // 简化格式：{ id: xxx }
            messageId = res.data.id;
          } else if (typeof res.data === 'object') {
            // 尝试在返回对象中查找id字段
            for (const key in res.data) {
              if (res.data[key] && res.data[key].id) {
                messageId = res.data[key].id;
                break;
              }
            }
          }
          
          // 更新本地消息状态为已发送
          that.updateMessageStatus(tempMessageId, 'sent');
          
          // 如果找到了真实的消息ID，更新本地消息ID
          if (messageId) {
            that.updateMessageId(tempMessageId, messageId);
          }
          
          // 一次成功后，马上轮询一次以获取最新消息
          setTimeout(() => {
            that.loadMessages(false);
          }, 300);
        } else {
          console.error('图片消息发送失败:', res);
          // 更新本地消息状态为发送失败
          that.updateMessageStatus(tempMessageId, 'failed');
          
          wx.showToast({
            title: (res.data && res.data.message) ? res.data.message : '发送失败，请重试',
            icon: 'none'
          });
        }
      },
      fail: function(err) {
        console.error('图片消息网络请求失败:', err);
        // 更新本地消息状态为发送失败
        that.updateMessageStatus(tempMessageId, 'failed');
        
        wx.showToast({
          title: '网络错误，发送失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 预览图片
   */
  previewImage: function(e) {
    const url = e.currentTarget.dataset.url;
    console.log('预览图片:', url);
    
    wx.previewImage({
      urls: [url],
      current: url
    });
  },
  
  /**
   * 图片加载错误处理
   */
  imageLoadError: function(e) {
    console.error('图片加载失败:', e);
    const messageId = e.currentTarget.dataset.id;
    
    // 尝试更新消息状态为失败
    const messages = this.data.messages;
    const index = messages.findIndex(msg => msg.id === messageId);
    
    if (index !== -1) {
      this.setData({
        [`messages[${index}].loadError`]: true
      });
    }
  },

  /**
   * 检查并确保WebSocket连接
   */
  checkAndConnectWebSocket: function() {
    // 获取当前用户信息
    const app = getApp();
    let userInfo = null;
    
    console.log('当前用户类型:', app.globalData.userType, 'isStaff:', app.globalData.isStaff);
    
    // 1. 首先尝试从全局数据获取
    if (app.globalData.isStaff) {
      userInfo = app.globalData.staffInfo;
      console.log('从全局staffInfo获取用户信息:', userInfo);
    } else {
      userInfo = app.globalData.userInfo;
      console.log('从全局userInfo获取用户信息:', userInfo);
    }
    
    // 2. 如果全局数据中没有，尝试从缓存获取
    if (!userInfo || !userInfo.id) {
      try {
        if (app.globalData.isStaff) {
          const cachedStaffInfo = wx.getStorageSync('staffInfo');
          if (cachedStaffInfo && cachedStaffInfo.id) {
            userInfo = cachedStaffInfo;
            console.log('从缓存staffInfo获取用户信息:', userInfo);
            
            // 更新全局数据
            app.globalData.staffInfo = cachedStaffInfo;
          }
        } else {
          const cachedUserInfo = wx.getStorageSync('userInfo');
          if (cachedUserInfo && cachedUserInfo.id) {
            userInfo = cachedUserInfo;
            console.log('从缓存userInfo获取用户信息:', userInfo);
            
            // 更新全局数据
            app.globalData.userInfo = cachedUserInfo;
          }
        }
      } catch (e) {
        console.error('从缓存获取用户信息失败:', e);
      }
    }
    
    // 检查是否有有效的用户信息
    if (!userInfo || !userInfo.id) {
      console.warn('未能获取有效的用户信息，可能会影响消息发送');
      
      // 如果没有token，提示用户登录
      if (!app.globalData.token) {
        wx.showModal({
          title: '提示',
          content: '用户信息不完整，请先登录',
          confirmText: '去登录',
          success: (res) => {
            if (res.confirm) {
              wx.navigateTo({
                url: '/pages/login/login?redirect=' + encodeURIComponent(`/pages/consult/chat?id=${this.data.conversationId}&status=${this.data.conversationStatus || 0}`)
              });
            } else {
              wx.navigateBack();
            }
          }
        });
        return;
      }
    }
    
    this.setData({
      userInfo: userInfo
    });
    
    // 如果会话已结束，不建立WebSocket连接
    if (this.data.conversationStatus === 1) {
      console.log('会话已结束，不建立WebSocket连接');
      return;
    }
    
    // 建立WebSocket连接
    // 如果有WebSocket连接相关的代码，放在这里
  },
});